package com.ptms.service;

import com.ptms.entity.User;
import com.ptms.repository.UserRepository;
import com.ptms.vo.ResultVO;
import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import org.springframework.transaction.annotation.Transactional;
import java.util.Optional;
import java.util.regex.Pattern;
import com.ptms.dto.PasswordChangeDTO;
import java.util.List;

import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import java.util.Optional;


@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserRepository userRepository;


    @Autowired
    private PasswordEncoder passwordEncoder;

    // 密码强度验证正则：6-20位，包含字母和数字
    private static final Pattern PASSWORD_PATTERN = Pattern.compile("^(?=.*[a-zA-Z])(?=.*\\d).{6,20}$");


    /**
     * 1. 获取当前登录用户信息（核心修改：调用新方法 findUserByUsername）
     */
    @Override
    public ResultVO<User> getCurrentUser(String username) {
        if (ObjectUtils.isEmpty(username)) {
            return ResultVO.fail(401, "用户身份已失效，请重新登录");
        }

        // 关键修改：从 findByUsername 改为 findUserByUsername，匹配 Repository 新方法
        Optional<User> userOpt = userRepository.findUserByUsername(username);
        if (userOpt.isPresent()) {
            return ResultVO.success(userOpt.get());
        } else {
            return ResultVO.fail(404, "当前用户不存在");
        }
    }


    // 以下 2、3 方法逻辑不变，保持原代码即可


    @Override
    public ResultVO<User> updateCurrentUser(String username, User updateInfo) {
        // 同样修改：调用新方法 findUserByUsername 定位当前用户
        Optional<User> userOpt = userRepository.findUserByUsername(username);
        if (!userOpt.isPresent()) {
            return ResultVO.fail(404, "用户不存在，请重新登录");
        }

        User originalUser = userOpt.get();

        if (!ObjectUtils.isEmpty(updateInfo.getRealName())) {
            originalUser.setRealName(updateInfo.getRealName());
        }
        if (!ObjectUtils.isEmpty(updateInfo.getPhone())) {
            originalUser.setPhone(updateInfo.getPhone());
        }
        if (!ObjectUtils.isEmpty(updateInfo.getGender())) {
            originalUser.setGender(updateInfo.getGender());
        }
        if (updateInfo.getAge() != null) {
            originalUser.setAge(updateInfo.getAge());
        }
        if (!ObjectUtils.isEmpty(updateInfo.getEmail())) {
            originalUser.setEmail(updateInfo.getEmail());
        }
        if (!ObjectUtils.isEmpty(updateInfo.getPhoto())) {
            originalUser.setPhoto(updateInfo.getPhoto());
        }

        User updatedUser = userRepository.save(originalUser);
        return ResultVO.success("用户信息更新成功", updatedUser);
    }


    /**
     * 4. 修改用户密码（核心逻辑：验证原密码+新密码强度校验+更新密码）
     */
    @Override
    @Transactional
    public ResultVO<Void> changeUserPassword(String username, PasswordChangeDTO passwordChangeDTO) {
        // 校验用户名有效性
        if (ObjectUtils.isEmpty(username)) {
            return ResultVO.fail(401, "用户身份已失效，请重新登录");
        }

        // 校验密码参数完整性
        if (passwordChangeDTO == null) {
            return ResultVO.fail(400, "密码信息不能为空");
        }
        if (ObjectUtils.isEmpty(passwordChangeDTO.getOldPassword())) {
            return ResultVO.fail(400, "原密码不能为空");
        }
        if (ObjectUtils.isEmpty(passwordChangeDTO.getNewPassword())) {
            return ResultVO.fail(400, "新密码不能为空");
        }

        // 查询用户信息（使用完整信息查询方法）
        Optional<User> userOpt = userRepository.findUserByUsername(username);
        if (!userOpt.isPresent()) {
            return ResultVO.fail(404, "当前用户不存在");
        }
        User user = userOpt.get();

        // 验证原密码正确性
        if (!passwordEncoder.matches(passwordChangeDTO.getOldPassword(), user.getPassword())) {
            return ResultVO.fail(400, "原密码不正确");
        }

        // 验证新密码强度
        if (!PASSWORD_PATTERN.matcher(passwordChangeDTO.getNewPassword()).matches()) {
            return ResultVO.fail(400, "新密码需包含字母和数字，长度6-20位");
        }

        // 检查新旧密码是否相同
        if (passwordEncoder.matches(passwordChangeDTO.getNewPassword(), user.getPassword())) {
            return ResultVO.fail(400, "新密码不能与原密码相同");
        }

        // 更新密码（加密存储）
        user.setPassword(passwordEncoder.encode(passwordChangeDTO.getNewPassword()));
        userRepository.save(user);

        return ResultVO.<Void>success ("密码修改成功", null);
    }
    @Override
    public ResultVO<List<User>> getAllStudents() {
        List<User> students = userRepository.findByUserType("student");
        return ResultVO.success(students);
    }

    /**
     * 6. 根据校区ID查询相同校区的学生数据
     */
    @Override
    public ResultVO<List<User>> getStudentsByCampusId(Long campusId) {
        if (ObjectUtils.isEmpty(campusId)) {
            return ResultVO.fail(400, "校区ID不能为空");
        }

        List<User> students = userRepository.findByCampusId_IdAndUserType(campusId, "student");
        return ResultVO.success(students);
    }

}


